home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / glass / glass.lha / GLASS / glue / dprocs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-01-31  |  7.0 KB  |  333 lines

  1.  
  2. /*
  3.  
  4.     This file is a part of the GLASS source distribution 
  5.     and therefore subjected to the copy notice below. 
  6.     
  7.     Copyright (C) 1989,1990  S.J. Klaver, R Doesborg
  8.               email: simon@sagan.nl
  9.  
  10.     This program is free software; you can redistribute it and/or modify
  11.     it under the terms of the GNU General Public License as published by
  12.     the Free Software Foundation version 1
  13.  
  14.     This program is distributed in the hope that it will be useful,
  15.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.     GNU General Public License for more details.
  18.  
  19.     You should have received a copy of the GNU General Public License
  20.     along with this program; if not, write to the Free Software
  21.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22. */
  23. /* File: wdisplayprocs.c
  24.    Authors: R. Doesborg, S.J. Klaver
  25. */
  26.  
  27. #include <stdio.h>
  28. #include <curses.h>
  29. #include "gconst.h"
  30. #include "errnum.h"
  31. #include "boxdefs.h"
  32. #include "tctypes.h"
  33. #include "globalvars.h"
  34.  
  35. extern char *malloc();
  36.  
  37. /* ATTR means if your curses implementation knows
  38.    screen attributes
  39. */
  40. #ifdef ATTR
  41. #define WREVERSE_ON(win)     wattron(win, A_REVERSE)
  42. #define WREVERSE_OFF(win)    wattroff(win, A_REVERSE)
  43. #define WBOLD_ON(win)        wattron(win, A_BOLD)
  44. #define WBOLD_OFF(win)       wattronff(win, A_BOLD)
  45. #else
  46. #define WREVERSE_ON(win)     wstandout(win)
  47. #define WREVERSE_OFF(win)    wstandend(win)
  48. #define WBOLD_ON(win)        wstandout(win)
  49. #define WBOLD_OFF(win)       wstandend(win)
  50. #endif
  51.  
  52. #define MAXLINES 25
  53. static int delay_buffer[MAXLINES];
  54. static int bufpoint = 0;
  55.  
  56.  
  57. void wdelayed_delete (win, line)
  58.   int line;
  59.   WINDOW *win;
  60. {
  61.   if (bufpoint<=MAXLINES) {
  62.     delay_buffer[bufpoint] = line;
  63.     bufpoint++;
  64.   }
  65.   else {
  66.     wmove(win, line, 0); wclrtoeol(win);
  67.   }
  68. }
  69.  
  70. void del_delay_buf (win)
  71.   WINDOW *win;
  72. {
  73.   while (bufpoint > 0) {
  74.     bufpoint--;
  75.     wmove(win, delay_buffer[bufpoint], 0);
  76.     wclrtoeol(win);
  77.   }
  78. }
  79.  
  80. /* first time setup of curses */
  81. void init_screen ()
  82. {
  83.   freopen("/dev/tty", "r+", stdin);
  84.   initscr();
  85.   nonl();
  86.   crmode();  
  87.   noecho();
  88.   refresh();
  89. }
  90.  
  91. void wclear_screen (win)
  92.   WINDOW *win;
  93. {
  94.   wclear(win); wrefresh(win);
  95. }
  96.  
  97. /* clear screen win and exit curses */
  98. void wexit_screen (win)
  99.   WINDOW *win;
  100. {
  101.   wclear_screen(win);
  102.   endwin();
  103. }
  104.  
  105. void switchtounbuffered ()
  106. {
  107.   nonl();
  108.   crmode();  
  109.   noecho();
  110. }
  111.  
  112. void switchtobuffered ()
  113. {
  114.   nl();
  115.   echo();
  116.   nocrmode(); 
  117. }
  118.  
  119. void wdraw_box (win, y0, x0, y1, x1)
  120.   WINDOW *win;
  121.   int y0, x0, y1, x1;
  122. {
  123.   int i;
  124.   mvwaddch (win, y0, x0, BOXTL);
  125.   mvwaddch (win, y0, x1, BOXTR);
  126.   mvwaddch (win, y1, x0, BOXBL);
  127.   mvwaddch (win, y1, x1, BOXBR);
  128.   for (i=x0+1; i<=x1-1; i++) {
  129.     mvwaddch (win, y0, i, BOXH);
  130.     mvwaddch (win, y1, i, BOXH);
  131.   }
  132.   for (i=y0+1; i<=y1-1; i++) {
  133.     mvwaddch (win, i, x0, BOXV);
  134.     mvwaddch (win, i, x1, BOXV);
  135.   }
  136. }
  137.  
  138.  
  139. /* str is a buffer, already allocated, that contains the
  140.    default value.  */
  141. void wgetstr_edit (win, edit_buf, maxlen)
  142.   WINDOW *win;
  143.   char *edit_buf;
  144.   int maxlen;
  145. {
  146.   int x, y, c, len = 0;
  147.  
  148.   getyx(win, y, x);
  149.   mvwaddstr (win, y, x, edit_buf);
  150.   len = strlen(edit_buf);
  151.   wmove(win, y, x+len);
  152.   wrefresh(win);
  153.   
  154.   c = wgetch (win);
  155.  
  156.   while ((c != KEY_RETURN) && (c != 13) && (c != 10)) {   /* <return> */
  157.     if ((c == 127) || (c == 8)) {    /* <backspace> or <erase> */
  158.       if (len > 0) {                 /* not at beginning of string */
  159.         len = len - 1;
  160.         edit_buf[len] = (char)0;
  161.         mvwaddch(win, y, x+len, ' '); 
  162.         wmove(win, y, x+len);
  163.         wrefresh(win);
  164.       }
  165.     }
  166.     else 
  167.     if (c == 21) {                 /* <erase line> */
  168.       while (len > 0) {
  169.         len = len - 1;
  170.         mvwaddch(win, y, x+len, ' '); 
  171.       }    
  172.       /* len == 0 */
  173.       edit_buf[0] = (char)0;
  174.       wmove(win, y, x);
  175.       wrefresh(win);
  176.     }
  177.     else 
  178.     if (  (c < 127)                 /* character, len < maxlen */
  179.        && (c >= 32)
  180.        && (len < maxlen)) {  
  181.       edit_buf[len] = (char)c;
  182.       mvwaddch(win, y, x+len, (char)c);
  183.       len = len + 1;
  184.       edit_buf[len] = (char)0;
  185.       wrefresh(win);
  186.     }
  187.     c = wgetch (win);
  188.   }
  189. }
  190.  
  191.  
  192. int werase_word (win, row, column, len)
  193.   WINDOW *win;
  194.   int row, column, len;
  195. {
  196.   int i;
  197.   for (i=0; i<len; i++) 
  198.     mvwaddch (win, row, column+i, ' ');
  199.   return(0);
  200. }
  201.  
  202. int wdisplay_string (win, str, row, column, attr)
  203.   WINDOW *win;
  204.   char *str;
  205.   int row;
  206.   int column;
  207.   int attr;
  208. {
  209.   if (strlen(str)+column > LINELENGTH)
  210.      return(1);
  211.   if (attr==REVERSE)
  212.     WREVERSE_ON(win); 
  213.   else if (attr==BOLD)
  214.     WBOLD_ON(win); 
  215.   mvwaddstr(win, row, column, str);
  216.   if (attr==REVERSE)
  217.     WREVERSE_OFF(win);
  218.   else if (attr==BOLD)
  219.     WBOLD_OFF(win);
  220.   del_delay_buf(win);   /* oppassen met deze */
  221.   wrefresh(win);
  222.   return(0);
  223. }
  224.  
  225.  
  226. /* Displays keywords.  If the display attribute is NORMAL, the
  227.    identifying character is displayed in BOLD.
  228. */
  229. int wdisplay_keyword (win, str, row, column, attr, idchar, idpos)
  230.   WINDOW *win;
  231.   int row, column, attr, idpos;
  232.   char *str;
  233.   char idchar;
  234.   int err;
  235.   err = wdisplay_string (win, str, row, column, attr);
  236.   if (attr == NORMAL) {
  237.     wmove (win, row, column+idpos-1); 
  238.     WBOLD_ON(win);
  239.     waddch (win, idchar);
  240.     WBOLD_OFF(win);
  241.   }
  242.   return(err);
  243. }
  244.  
  245. void wdisplay_error (win, errnum)
  246.   WINDOW *win;
  247.   int errnum;
  248. {
  249.   wmove(win, 23, 1);
  250.   switch (errnum) {
  251.     case errNOQUST:
  252.       waddstr(win, "Cannot go to higher menu (use Exit to quit program)");
  253.       break;
  254.     case errILLKEY:
  255.       waddstr(win, "This key is not defined in this menu");
  256.       break;
  257.     default:
  258.       waddstr(win, "Unknown errormessage");
  259.       break;
  260.   }
  261.   wrefresh(win);
  262.   wdelayed_delete (win, 23);
  263. }
  264.  
  265. int wget_key (win)
  266.   WINDOW *win;
  267. {
  268.   int key1, key2, key3;
  269.   int result, t;
  270.  
  271.   wmove (win, 23,1); wrefresh(win);
  272.  
  273.   /* the following section reads a character and does a shell  */
  274.   /* escape if ! is pressed                                    */
  275.  
  276.   do {
  277.     key1 = wgetch(win);
  278.     if (key1 == '!') {
  279.       endwin();
  280.       printf ("\n\nLogout to return to GLUE.\n"); 
  281.       if (cshell) 
  282.         system ("csh");
  283.       else
  284.         system ("sh");
  285.       printf ("\nBack in GLUE.\n");
  286.       wrefresh(curscr); 
  287.       crmode(); noecho(); nonl();
  288.       key1 = wgetch(win);
  289.       break;
  290.     }
  291.   }
  292.   while (key1 == '!');
  293.   /* key1 <> '!' */
  294.  
  295.   if (key1 == KEY_ESCAPE) {
  296.     /* nodelay(win, 1); */
  297.     for (t=0; ((key2 = wgetch(win)) == ERR) && t<100; t++);
  298.     if (key2 == ERR)
  299.       result = key1;
  300.     else {
  301.       for (t=0; ((key3 = wgetch(win)) == ERR) && t<100; t++);
  302.       if (key3 == ERR)
  303.         result = ERR;
  304.       else {
  305.         if (key2 == '[') {
  306.           switch (key3) {
  307.             case 'A':
  308.               result = KEY_UP;
  309.               break;
  310.             case 'B':
  311.               result = KEY_DOWN;
  312.               break;
  313.             case 'C':
  314.               result = KEY_RIGHT;
  315.               break;
  316.             case 'D':
  317.               result = KEY_LEFT;
  318.               break;
  319.             default:
  320.               result = ERR;
  321.               break;
  322.           }
  323.         }
  324.         else result = ERR;
  325.       }
  326.     }
  327.   /* nodelay(win, 0); */
  328.   }
  329.   else result = key1;
  330.   return(result);
  331. }
  332.